using System; 
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Transactions;
 
namespace System.Data.Linq.SqlClient {
    /// <summary> 
    /// DLinq-providerbase-specific custom exception factory. 
    /// </summary>
    internal static partial class Error { 
        /// <summary>
        /// Exception thrown when a query cannot execute against a particular SQL server version.
        /// </summary>
        static internal Exception ExpressionNotSupportedForSqlServerVersion(Collection<string> reasons) { 
            StringBuilder exceptionMessage = new StringBuilder(Strings.CannotTranslateExpressionToSql);
            foreach (string reason in reasons) { 
                exceptionMessage.AppendLine(reason); 
            }
            return new NotSupportedException(exceptionMessage.ToString()); 
        }
    }

} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
namespace System.Data.Linq.SqlClient
{
    internal static partial class Error
    {
        // Methods
        internal static Exception ArgumentEmpty(object p0)
        {
            return new ArgumentException(string.Format(Strings.ArgumentEmpty,p0));
        }

        internal static Exception ArgumentNull(string paramName)
        {
            return new ArgumentNullException(paramName);
        }

        internal static Exception ArgumentOutOfRange(string paramName)
        {
            return new ArgumentOutOfRangeException(paramName);
        }

        internal static Exception ArgumentTypeMismatch(object p0)
        {
            return new ArgumentException(string.Format(Strings.ArgumentTypeMismatch,p0));
        }

        internal static Exception ArgumentWrongType(object p0, object p1, object p2)
        {
            return new ArgumentException(string.Format(Strings.ArgumentWrongType,p0, p1, p2));
        }

        internal static Exception ArgumentWrongValue(object p0)
        {
            return new ArgumentException(string.Format(Strings.ArgumentWrongValue,p0));
        }

        internal static Exception BadParameterType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.BadParameterType,p0));
        }

        internal static Exception BadProjectionInSelect()
        {
            return new InvalidOperationException(Strings.BadProjectionInSelect);
        }

        internal static Exception BinaryOperatorNotRecognized(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.BinaryOperatorNotRecognized,p0));
        }

        internal static Exception CannotAggregateType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.CannotAggregateType,p0));
        }

        internal static Exception CannotAssignNull(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CannotAssignNull,p0));
        }

        internal static Exception CannotAssignToMember(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CannotAssignToMember,p0));
        }

        internal static Exception CannotCompareItemsAssociatedWithDifferentTable()
        {
            return new InvalidOperationException(Strings.CannotCompareItemsAssociatedWithDifferentTable);
        }

        internal static Exception CannotConvertToEntityRef(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CannotConvertToEntityRef,p0));
        }

        internal static Exception CannotDeleteTypesOf(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CannotDeleteTypesOf,p0));
        }

        internal static Exception CannotEnumerateResultsMoreThanOnce()
        {
            return new InvalidOperationException(Strings.CannotEnumerateResultsMoreThanOnce);
        }

        internal static Exception CannotMaterializeList(object p0)
        {
            return new NotSupportedException(string.Format(Strings.CannotMaterializeList,p0));
        }

        internal static Exception CannotMaterializeEntityType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.CannotMaterializeEntityType,p0));
        }

        internal static Exception CapturedValuesCannotBeSequences()
        {
            return new NotSupportedException(Strings.CapturedValuesCannotBeSequences);
        }

        internal static Exception ClassLiteralsNotAllowed(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ClassLiteralsNotAllowed,p0));
        }

        internal static Exception ClientCaseShouldNotHold(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ClientCaseShouldNotHold,p0));
        }

        internal static Exception ClrBoolDoesNotAgreeWithSqlType(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ClrBoolDoesNotAgreeWithSqlType,p0));
        }

        internal static Exception ColumnCannotReferToItself()
        {
            return new InvalidOperationException(Strings.ColumnCannotReferToItself);
        }

        internal static Exception ColumnClrTypeDoesNotAgreeWithExpressionsClrType()
        {
            return new InvalidOperationException(Strings.ColumnClrTypeDoesNotAgreeWithExpressionsClrType);
        }

        internal static Exception ColumnIsDefinedInMultiplePlaces(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ColumnIsDefinedInMultiplePlaces,p0));
        }

        internal static Exception ColumnIsNotAccessibleThroughDistinct(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ColumnIsNotAccessibleThroughDistinct,p0));
        }

        internal static Exception ColumnIsNotAccessibleThroughGroupBy(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ColumnIsNotAccessibleThroughGroupBy,p0));
        }

        internal static Exception ColumnReferencedIsNotInScope(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ColumnReferencedIsNotInScope,p0));
        }

        internal static Exception ComparisonNotSupportedForType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.ComparisonNotSupportedForType,p0));
        }

        internal static Exception CompiledQueryAgainstMultipleShapesNotSupported()
        {
            return new NotSupportedException(Strings.CompiledQueryAgainstMultipleShapesNotSupported);
        }

        internal static Exception CompiledQueryCannotReturnType(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CompiledQueryCannotReturnType,p0));
        }

        internal static Exception ConstructedArraysNotSupported()
        {
            return new NotSupportedException(Strings.ConstructedArraysNotSupported);
        }

        internal static Exception ContextNotInitialized()
        {
            return new InvalidOperationException(Strings.ContextNotInitialized);
        }

        internal static Exception ConvertToCharFromBoolNotSupported()
        {
            return new NotSupportedException(Strings.ConvertToCharFromBoolNotSupported);
        }

        internal static Exception ConvertToDateTimeOnlyForDateTimeOrString()
        {
            return new NotSupportedException(Strings.ConvertToDateTimeOnlyForDateTimeOrString);
        }

        internal static Exception CouldNotAssignSequence(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotAssignSequence,p0, p1));
        }

        internal static Exception CouldNotConvert(object p0, object p1)
        {
            return new InvalidCastException(string.Format(Strings.CouldNotConvert,p0, p1));
        }

        internal static Exception CouldNotConvertToPropertyOrField(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotConvertToPropertyOrField,p0));
        }

        internal static Exception CouldNotDetermineCatalogName()
        {
            return new InvalidOperationException(Strings.CouldNotDetermineCatalogName);
        }

        internal static Exception CouldNotDetermineDbGeneratedSqlType(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotDetermineDbGeneratedSqlType,p0));
        }

        internal static Exception CouldNotDetermineSqlType(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotDetermineSqlType,p0));
        }

        internal static Exception CouldNotGetClrType()
        {
            return new InvalidOperationException(Strings.CouldNotGetClrType);
        }

        internal static Exception CouldNotGetSqlType()
        {
            return new InvalidOperationException(Strings.CouldNotGetSqlType);
        }

        internal static Exception CouldNotHandleAliasRef(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotHandleAliasRef,p0));
        }

        internal static Exception CouldNotTranslateExpressionForReading(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CouldNotTranslateExpressionForReading,p0));
        }

        internal static Exception CreateDatabaseFailedBecauseOfClassWithNoMembers(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CreateDatabaseFailedBecauseOfClassWithNoMembers,p0));
        }

        internal static Exception CreateDatabaseFailedBecauseOfContextWithNoTables(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CreateDatabaseFailedBecauseOfContextWithNoTables,p0));
        }

        internal static Exception CreateDatabaseFailedBecauseSqlCEDatabaseAlreadyExists(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.CreateDatabaseFailedBecauseSqlCEDatabaseAlreadyExists,p0));
        }

        internal static Exception DatabaseDeleteThroughContext()
        {
            return new InvalidOperationException(Strings.DatabaseDeleteThroughContext);
        }

        internal static Exception DeferredMemberWrongType()
        {
            return new InvalidOperationException(Strings.DeferredMemberWrongType);
        }

        internal static Exception DidNotExpectAs(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.DidNotExpectAs,p0));
        }

        internal static Exception DidNotExpectTypeBinding()
        {
            return new InvalidOperationException(Strings.DidNotExpectTypeBinding);
        }

        internal static Exception DidNotExpectTypeChange(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.DidNotExpectTypeChange,p0, p1));
        }

        internal static Exception DistributedTransactionsAreNotAllowed()
        {
            return new TransactionPromotionException(Strings.DistributedTransactionsAreNotAllowed);
        }

        internal static Exception EmptyCaseNotSupported()
        {
            return new InvalidOperationException(Strings.EmptyCaseNotSupported);
        }

        internal static Exception ExceptNotSupportedForHierarchicalTypes()
        {
            return new NotSupportedException(Strings.ExceptNotSupportedForHierarchicalTypes);
        }

        internal static Exception ExpectedBitFoundPredicate()
        {
            return new ArgumentException(Strings.ExpectedBitFoundPredicate);
        }

        internal static Exception ExpectedClrTypesToAgree(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.ExpectedClrTypesToAgree,p0, p1));
        }

        internal static Exception ExpectedNoObjectType()
        {
            return new InvalidOperationException(Strings.ExpectedNoObjectType);
        }

        internal static Exception ExpectedPredicateFoundBit()
        {
            return new ArgumentException(Strings.ExpectedPredicateFoundBit);
        }

        internal static Exception ExpectedQueryableArgument(object p0, object p1, object p2)
        {
            return new ArgumentException(string.Format(Strings.ExpectedQueryableArgument,p0, p1, p2));
        }

        internal static Exception ExpressionNotDeferredQuerySource()
        {
            return new InvalidOperationException(Strings.ExpressionNotDeferredQuerySource);
        }

        internal static Exception GeneralCollectionMaterializationNotSupported()
        {
            return new NotSupportedException(Strings.GeneralCollectionMaterializationNotSupported);
        }

        internal static Exception GroupingNotSupportedAsOrderCriterion()
        {
            return new NotSupportedException(Strings.GroupingNotSupportedAsOrderCriterion);
        }

        internal static Exception IifReturnTypesMustBeEqual(object p0, object p1)
        {
            return new NotSupportedException(string.Format(Strings.IifReturnTypesMustBeEqual,p0, p1));
        }

        internal static Exception Impossible()
        {
            return new InvalidOperationException(Strings.Impossible);
        }

        internal static Exception IndexOfWithStringComparisonArgNotSupported()
        {
            return new NotSupportedException(Strings.IndexOfWithStringComparisonArgNotSupported);
        }

        internal static Exception InfiniteDescent()
        {
            return new InvalidOperationException(Strings.InfiniteDescent);
        }

        internal static Exception InsertItemMustBeConstant()
        {
            return new NotSupportedException(Strings.InsertItemMustBeConstant);
        }

        internal static Exception IntersectNotSupportedForHierarchicalTypes()
        {
            return new NotSupportedException(Strings.IntersectNotSupportedForHierarchicalTypes);
        }

        internal static Exception InvalidConnectionArgument(object p0)
        {
            return new ArgumentException(string.Format(Strings.InvalidConnectionArgument,p0));
        }

        internal static Exception InvalidDbGeneratedType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.InvalidDbGeneratedType,p0));
        }

        internal static Exception InvalidFormatNode(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.InvalidFormatNode,p0));
        }

        internal static Exception InvalidGroupByExpression()
        {
            return new NotSupportedException(Strings.InvalidGroupByExpression);
        }

        internal static Exception InvalidGroupByExpressionType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.InvalidGroupByExpressionType,p0));
        }

        internal static Exception InvalidMethodExecution(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.InvalidMethodExecution,p0));
        }

        internal static Exception InvalidOrderByExpression(object p0)
        {
            return new NotSupportedException(string.Format(Strings.InvalidOrderByExpression,p0));
        }

        internal static Exception InvalidProviderType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.InvalidProviderType,p0));
        }

        internal static Exception InvalidReferenceToRemovedAliasDuringDeflation()
        {
            return new InvalidOperationException(Strings.InvalidReferenceToRemovedAliasDuringDeflation);
        }

        internal static Exception InvalidReturnFromSproc(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.InvalidReturnFromSproc,p0));
        }

        internal static Exception InvalidSequenceOperatorCall(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.InvalidSequenceOperatorCall,p0));
        }

        internal static Exception IQueryableCannotReturnSelfReferencingConstantExpression()
        {
            return new NotSupportedException(Strings.IQueryableCannotReturnSelfReferencingConstantExpression);
        }

        internal static Exception LastIndexOfWithStringComparisonArgNotSupported()
        {
            return new NotSupportedException(Strings.LastIndexOfWithStringComparisonArgNotSupported);
        }

        internal static Exception MappedTypeMustHaveDefaultConstructor(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.MappedTypeMustHaveDefaultConstructor,p0));
        }

        internal static Exception MathRoundNotSupported()
        {
            return new NotSupportedException(Strings.MathRoundNotSupported);
        }

        internal static Exception MemberAccessIllegal(object p0, object p1, object p2)
        {
            return new InvalidOperationException(string.Format(Strings.MemberAccessIllegal,p0, p1, p2));
        }

        internal static Exception MemberCannotBeTranslated(object p0, object p1)
        {
            return new NotSupportedException(string.Format(Strings.MemberCannotBeTranslated,p0, p1));
        }

        internal static Exception MemberCouldNotBeTranslated(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.MemberCouldNotBeTranslated,p0, p1));
        }

        internal static Exception MemberNotPartOfProjection(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.MemberNotPartOfProjection,p0, p1));
        }

        internal static Exception MethodFormHasNoSupportConversionToSql(object p0, object p1)
        {
            return new NotSupportedException(string.Format(Strings.MethodFormHasNoSupportConversionToSql,p0, p1));
        }

        internal static Exception MethodHasNoSupportConversionToSql(object p0)
        {
            return new NotSupportedException(string.Format(Strings.MethodHasNoSupportConversionToSql,p0));
        }

        internal static Exception MethodNotMappedToStoredProcedure(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.MethodNotMappedToStoredProcedure,p0));
        }

        internal static Exception NoMethodInTypeMatchingArguments(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.NoMethodInTypeMatchingArguments,p0));
        }

        internal static Exception NonConstantExpressionsNotSupportedFor(object p0)
        {
            return new NotSupportedException(string.Format(Strings.NonConstantExpressionsNotSupportedFor,p0));
        }

        internal static Exception NonConstantExpressionsNotSupportedForRounding()
        {
            return new NotSupportedException(Strings.NonConstantExpressionsNotSupportedForRounding);
        }

        internal static Exception NonCountAggregateFunctionsAreNotValidOnProjections(object p0)
        {
            return new NotSupportedException(string.Format(Strings.NonCountAggregateFunctionsAreNotValidOnProjections,p0));
        }

        internal static Exception NotImplemented()
        {
            return new NotImplementedException();
        }

        internal static Exception NotSupported()
        {
            return new NotSupportedException();
        }

        internal static Exception ParameterNotInScope(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ParameterNotInScope,p0));
        }

        internal static Exception ParametersCannotBeSequences()
        {
            return new NotSupportedException(Strings.ParametersCannotBeSequences);
        }

        internal static Exception ProviderCannotBeUsedAfterDispose()
        {
            return new ObjectDisposedException(Strings.ProviderCannotBeUsedAfterDispose);
        }

        internal static Exception ProviderNotInstalled(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.ProviderNotInstalled,p0, p1));
        }

        internal static Exception QueryOnLocalCollectionNotSupported()
        {
            return new NotSupportedException(Strings.QueryOnLocalCollectionNotSupported);
        }

        internal static Exception QueryOperatorNotSupported(object p0)
        {
            return new NotSupportedException(string.Format(Strings.QueryOperatorNotSupported,p0));
        }

        internal static Exception QueryOperatorOverloadNotSupported(object p0)
        {
            return new NotSupportedException(string.Format(Strings.QueryOperatorOverloadNotSupported,p0));
        }

        internal static Exception ReaderUsedAfterDispose()
        {
            return new InvalidOperationException(Strings.ReaderUsedAfterDispose);
        }

        internal static Exception RequiredColumnDoesNotExist(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.RequiredColumnDoesNotExist,p0));
        }

        internal static Exception ResultTypeNotMappedToFunction(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.ResultTypeNotMappedToFunction,p0, p1));
        }

        internal static Exception SelectManyDoesNotSupportStrings()
        {
            return new ArgumentException(Strings.SelectManyDoesNotSupportStrings);
        }

        internal static Exception SequenceOperatorsNotSupportedForType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.SequenceOperatorsNotSupportedForType,p0));
        }

        internal static Exception SimpleCaseShouldNotHold(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.SimpleCaseShouldNotHold,p0));
        }

        internal static Exception SkipIsValidOnlyOverOrderedQueries()
        {
            return new InvalidOperationException(Strings.SkipIsValidOnlyOverOrderedQueries);
        }

        internal static Exception SkipNotSupportedForSequenceTypes()
        {
            return new NotSupportedException(Strings.SkipNotSupportedForSequenceTypes);
        }

        internal static Exception SkipRequiresSingleTableQueryWithPKs()
        {
            return new NotSupportedException(Strings.SkipRequiresSingleTableQueryWithPKs);
        }

        internal static Exception SprocsCannotBeComposed()
        {
            return new InvalidOperationException(Strings.SprocsCannotBeComposed);
        }

        internal static Exception SqlMethodOnlyForSql(object p0)
        {
            return new NotSupportedException(string.Format(Strings.SqlMethodOnlyForSql,p0));
        }

        internal static Exception ToStringOnlySupportedForPrimitiveTypes()
        {
            return new NotSupportedException(Strings.ToStringOnlySupportedForPrimitiveTypes);
        }

        internal static Exception TransactionDoesNotMatchConnection()
        {
            return new InvalidOperationException(Strings.TransactionDoesNotMatchConnection);
        }

        internal static Exception TypeBinaryOperatorNotRecognized()
        {
            return new InvalidOperationException(Strings.TypeBinaryOperatorNotRecognized);
        }

        internal static Exception TypeCannotBeOrdered(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.TypeCannotBeOrdered,p0));
        }

        internal static Exception TypeColumnWithUnhandledSource()
        {
            return new InvalidOperationException(Strings.TypeColumnWithUnhandledSource);
        }

        internal static Exception UnableToBindUnmappedMember(object p0, object p1, object p2)
        {
            return new InvalidOperationException(string.Format(Strings.UnableToBindUnmappedMember,p0, p1, p2));
        }

        internal static Exception UnexpectedFloatingColumn()
        {
            return new InvalidOperationException(Strings.UnexpectedFloatingColumn);
        }

        internal static Exception UnexpectedNode(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.UnexpectedNode,p0));
        }

        internal static Exception UnexpectedSharedExpression()
        {
            return new InvalidOperationException(Strings.UnexpectedSharedExpression);
        }

        internal static Exception UnexpectedSharedExpressionReference()
        {
            return new InvalidOperationException(Strings.UnexpectedSharedExpressionReference);
        }

        internal static Exception UnexpectedTypeCode(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.UnexpectedTypeCode,p0));
        }

        internal static Exception UnhandledBindingType(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.UnhandledBindingType,p0));
        }

        internal static Exception UnhandledExpressionType(object p0)
        {
            return new ArgumentException(string.Format(Strings.UnhandledExpressionType,p0));
        }

        internal static Exception UnhandledMemberAccess(object p0, object p1)
        {
            return new InvalidOperationException(string.Format(Strings.UnhandledMemberAccess,p0, p1));
        }

        internal static Exception UnhandledStringTypeComparison()
        {
            return new NotSupportedException(Strings.UnhandledStringTypeComparison);
        }

        internal static Exception UnionDifferentMemberOrder()
        {
            return new NotSupportedException(Strings.UnionDifferentMemberOrder);
        }

        internal static Exception UnionDifferentMembers()
        {
            return new NotSupportedException(Strings.UnionDifferentMembers);
        }

        internal static Exception UnionIncompatibleConstruction()
        {
            return new NotSupportedException(Strings.UnionIncompatibleConstruction);
        }

        internal static Exception UnionOfIncompatibleDynamicTypes()
        {
            return new NotSupportedException(Strings.UnionOfIncompatibleDynamicTypes);
        }

        internal static Exception UnionWithHierarchy()
        {
            return new NotSupportedException(Strings.UnionWithHierarchy);
        }

        internal static Exception UnmappedDataMember(object p0, object p1, object p2)
        {
            return new InvalidOperationException(string.Format(Strings.UnmappedDataMember,p0, p1, p2));
        }

        internal static Exception UnrecognizedExpressionNode(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.UnrecognizedExpressionNode,p0));
        }

        internal static Exception UnrecognizedProviderMode(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.UnrecognizedProviderMode,p0));
        }

        internal static Exception UnsafeStringConversion(object p0, object p1)
        {
            return new FormatException(string.Format(Strings.UnsafeStringConversion,p0, p1));
        }

        internal static Exception UnsupportedDateTimeConstructorForm()
        {
            return new NotSupportedException(Strings.UnsupportedDateTimeConstructorForm);
        }

        internal static Exception UnsupportedDateTimeOffsetConstructorForm()
        {
            return new NotSupportedException(Strings.UnsupportedDateTimeOffsetConstructorForm);
        }

        internal static Exception UnsupportedNodeType(object p0)
        {
            return new NotSupportedException(string.Format(Strings.UnsupportedNodeType,p0));
        }

        internal static Exception UnsupportedStringConstructorForm()
        {
            return new NotSupportedException(Strings.UnsupportedStringConstructorForm);
        }

        internal static Exception UnsupportedTimeSpanConstructorForm()
        {
            return new NotSupportedException(Strings.UnsupportedTimeSpanConstructorForm);
        }

        internal static Exception UnsupportedTypeConstructorForm(object p0)
        {
            return new NotSupportedException(string.Format(Strings.UnsupportedTypeConstructorForm,p0));
        }

        internal static Exception UpdateItemMustBeConstant()
        {
            return new NotSupportedException(Strings.UpdateItemMustBeConstant);
        }

        internal static Exception ValueHasNoLiteralInSql(object p0)
        {
            return new InvalidOperationException(string.Format(Strings.ValueHasNoLiteralInSql,p0));
        }

        internal static Exception VbLikeDoesNotSupportMultipleCharacterRanges()
        {
            return new ArgumentException(Strings.VbLikeDoesNotSupportMultipleCharacterRanges);
        }

        internal static Exception VbLikeUnclosedBracket()
        {
            return new ArgumentException(Strings.VbLikeUnclosedBracket);
        }

        internal static Exception WrongDataContext()
        {
            return new InvalidOperationException(Strings.WrongDataContext);
        }

        internal static Exception WrongNumberOfValuesInCollectionArgument(object p0, object p1, object p2)
        {
            return new ArgumentException(string.Format(Strings.WrongNumberOfValuesInCollectionArgument,p0, p1, p2));
        }
    }
}
